home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / languags / cc.1 < prev    next >
Text File  |  1989-04-26  |  43KB  |  1,732 lines
  1. Path: xanth!ames!purdue!tut.cis.ohio-state.edu!bloom-beacon!apple!oliveb!sun!rishathra!page
  2. From: page%rishathra@Sun.COM (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i099:  cc - unix-like front end for lattice 5.x
  5. Message-ID: <101403@sun.Eng.Sun.COM>
  6. Date: 26 Apr 89 21:36:34 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 1721
  9. Approved: page@sun.com
  10.  
  11. Submitted-by: bader+@andrew.cmu.edu (Miles Bader)
  12. Posting-number: Volume 89, Issue 99
  13. Archive-name: languages/cc.1
  14.  
  15. # This is a shell archive.
  16. # Remove anything above and including the cut line.
  17. # Then run the rest of the file through 'sh'.
  18. # Unpacked files will be owned by you and have default permissions.
  19. #----cut here-----cut here-----cut here-----cut here----#
  20. #!/bin/sh
  21. # shar: SHell ARchive
  22. # Run the following text through 'sh' to create:
  23. #    Makefile
  24. #    README
  25. #    builtins.make
  26. #    cc.c
  27. #    cc.doc
  28. #    config.h
  29. #    dstr.c
  30. #    dstr.h
  31. #    err.c
  32. #    list.c
  33. #    list.h
  34. #    op.c
  35. #    op.h
  36. #    options.c
  37. #    options.h
  38. # This is archive 1 of a 1-part kit.
  39. # This archive created: Wed Apr 26 14:31:28 1989
  40. echo "extracting Makefile"
  41. sed 's/^X//' << \SHAR_EOF > Makefile
  42. XDEBUG=    -O
  43. XOPTS=    +no-stack-check
  44. XFLAGS=    $(DEBUG) $(OPTS)
  45. XCFLAGS= $(FLAGS) $(DEFINES)
  46. XLFLAGS= $(FLAGS)
  47. X
  48. XLIBS=
  49. X
  50. XTARGET=    cc
  51. XOBJS=    cc.o list.o dstr.o err.o op.o options.o
  52. X
  53. X$(TARGET):    $(OBJS)
  54. X    ${CC} $(LFLAGS) -o $(TARGET) $(OBJS) $(LIBS)
  55. X
  56. X$(OBJS): common.h
  57. Xcc.o:    list.h dstr.h op.h options.h config.h
  58. Xcommon.h: dbug.h
  59. Xoptions.o: options.h
  60. Xdstr.o: dstr.h
  61. Xlist.o: list.h
  62. Xop.o: op.h
  63. SHAR_EOF
  64. echo "extracting README"
  65. sed 's/^X//' << \SHAR_EOF > README
  66. XSimple changes to cc's defaults can be made in config.h.  If you make a not-
  67. Xso-simple change, to implement some new feature, please send me back the
  68. Xchanges.  My email address is bader+@andrew.cmu.edu.
  69. X
  70. XThe Makefile and builtins.make (which goes in s: and defines default rules)
  71. Xare for the version of make that comes with pcc 3.0 (although I just noticed,
  72. Xit's ignoring time-stamps!  Anyone got a better make?)
  73. X
  74. X-Miles
  75. SHAR_EOF
  76. echo "extracting builtins.make"
  77. sed 's/^X//' << \SHAR_EOF > builtins.make
  78. XCC=cc
  79. X
  80. X.SUFFIXES: .c .o
  81. X
  82. X.c.o:
  83. X    ${CC} -c ${CFLAGS} $<
  84. SHAR_EOF
  85. echo "extracting cc.c"
  86. sed 's/^X//' << \SHAR_EOF > cc.c
  87. X/*
  88. X * cc -- unix-like compiler driver for amiga lattice c
  89. X *
  90. X * adapted for lattice version 5.0 and extensively modified
  91. X *   by Miles Bader, from the original by Fred Fish (copyright
  92. X *   follows).
  93. X */
  94. X
  95. X/************************************************************************
  96. X *                                    *
  97. X *            Copyright (c) 1985, Fred Fish            *
  98. X *                All Rights Reserved                *
  99. X *                                    *
  100. X *    This software and/or documentation is released into the        *
  101. X *    public domain for personal, non-commercial use only.        *
  102. X *    Limited rights to use, modify, and redistribute are hereby    *
  103. X *    granted for non-commercial purposes, provided that all        *
  104. X *    copyright notices remain intact and all changes are clearly    *
  105. X *    documented.  The author makes no warranty of any kind with    *
  106. X *    respect to this product and explicitly disclaims any implied    *
  107. X *    warranties of merchantability or fitness for any particular    *
  108. X *    purpose.                            *
  109. X *                                    *
  110. X ************************************************************************
  111. X */
  112. X
  113. X#include <stdio.h>
  114. X#include <stdlib.h>
  115. X#include <string.h>
  116. X
  117. X#include <dos.h>
  118. X#include <proto/dos.h>
  119. X#include <ios1.h> /* magic */
  120. X
  121. X#include "common.h"
  122. X#include "list.h"
  123. X#include "dstr.h"
  124. X#include "op.h"
  125. X#include "options.h"
  126. X
  127. X#include "config.h"
  128. X
  129. Xstatic char *locate(char *file,struct list *list);    /* find a file */
  130. Xstatic void cleanObjects(int mustExist);    /* Remove .o for link and go mode */
  131. Xstatic int makeObjs();            /* Reduce to list of object files */
  132. Xstatic int parseCommandLine();        /* Deal with command line */
  133. Xstatic int compile(struct op *op);    /* Translate from .c to .o */
  134. Xstatic int assemble(struct op *op);    /* Translate from .s to .o */
  135. Xstatic int link();            /* Gather .o's into executable */
  136. Xstatic int runCmd(struct dstr *cmd);
  137. X
  138. X#ifdef amiga
  139. X#define CHECK_ABORT chkabort()
  140. X#else
  141. X#define CHECK_ABORT                /* NULL expansion */
  142. X#endif    /* amiga */
  143. X 
  144. XDBUG_GLOBALS
  145. X
  146. X/*
  147. X *    flags set by command line arguments
  148. X */
  149. Xstatic int debugLevel=DEFAULT_DEBUGLEVEL;    /* -g (debugging level) */
  150. X
  151. Xstruct list *libDirs=NULL;
  152. Xstruct list *incDirs=NULL;
  153. Xstruct list *binDirs=NULL;
  154. Xstruct list *defines=NULL;
  155. Xstruct list *undefines=NULL;
  156. Xstruct list *libs=NULL;
  157. X
  158. Xstruct list *pass1PassThrus=NULL;
  159. Xstruct list *pass2PassThrus=NULL;
  160. Xstruct list *optPassThrus=NULL;
  161. Xstruct list *linkPassThrus=NULL;
  162. X
  163. Xstruct list *ops=NULL;
  164. X
  165. Xstatic char *outfile=DEFAULT_EXEC;    /* output file name from linker */
  166. Xstatic char *tempDir=TEMPDIR;        /* where to keep quad files */
  167. Xstatic char *sinkFile=SINKFILE;        /* where to put output from passes */
  168. X
  169. Xstruct dstr *cmdLine=NULL;
  170. X 
  171. Xstatic int abortmsg()
  172. X{
  173. X    if(options_IsSet(OPT_ECHO))
  174. X    fprintf(stderr,"cc: aborting\n");
  175. X    return 1; /* abort */
  176. X}
  177. X
  178. Xstatic int cleanup(status)
  179. Xint status;
  180. X{
  181. X    if(cmdLine!=NULL)    dstr_Free(cmdLine);
  182. X
  183. X    if(libDirs!=NULL)    list_Free(libDirs);
  184. X    if(incDirs!=NULL)    list_Free(incDirs);
  185. X    if(binDirs!=NULL)    list_Free(binDirs);
  186. X    if(defines!=NULL)    list_Free(defines);
  187. X    if(undefines!=NULL)    list_Free(undefines);
  188. X    if(libs!=NULL)    list_Free(libs);
  189. X
  190. X    if(pass1PassThrus!=NULL)    list_Free(pass1PassThrus);
  191. X    if(pass2PassThrus!=NULL)    list_Free(pass2PassThrus);
  192. X    if(optPassThrus!=NULL)    list_Free(optPassThrus);
  193. X    if(linkPassThrus!=NULL)    list_Free(linkPassThrus);
  194. X
  195. X    if(ops!=NULL)    list_Free(ops);
  196. X
  197. X    return status;
  198. X}
  199. X
  200. Xstatic void init()
  201. X{
  202. X    int *opt;
  203. X
  204. X    options_Init();
  205. X    for(opt=defaultOptions; *opt!=0; opt++)
  206. X    options_Set(*opt);
  207. X
  208. X    cmdLine=dstr_Create(30);        /* global command buffer */
  209. X
  210. X    libDirs=list_Create((void **)libDirsInit);
  211. X    incDirs=list_Create((void **)incDirsInit);
  212. X    binDirs=list_Create((void **)binDirsInit);
  213. X    defines=list_Create((void **)definesInit);
  214. X    undefines=list_Create((void **)undefinesInit);
  215. X    libs=list_Create((void **)libsInit);
  216. X
  217. X    pass1PassThrus=list_Create(NULL);
  218. X    pass2PassThrus=list_Create(NULL);
  219. X    optPassThrus=list_Create(NULL);
  220. X    linkPassThrus=list_Create(NULL);
  221. X
  222. X    ops=list_Create(NULL);
  223. X    list_SetFree(ops,op_Free);
  224. X}
  225. X
  226. Xvoid main(argc, argv)
  227. Xint argc;
  228. Xchar *argv[];
  229. X{
  230. X    int status;
  231. X
  232. X    DBUG_ENTER("main");
  233. X
  234. X    onexit(cleanup);
  235. X    init();
  236. X
  237. X    onbreak(abortmsg);
  238. X
  239. X    if(parseCommandLine(argc,argv)==0)
  240. X    fatal("no files specified");
  241. X
  242. X    cleanObjects(FALSE);    /* get rid of existing object files if any */
  243. X
  244. X    status=makeObjs();
  245. X    if(status==0 && options_IsSet(OPT_LINK)){
  246. X    status=link();
  247. X    if(list_GetLen(ops)==1)
  248. X        cleanObjects(TRUE);
  249. X    }
  250. X
  251. X    exit(status);
  252. X}
  253. X
  254. X/*
  255. X *    The following macro is used to allow optional whitespace between
  256. X *    an option and it's argument.  Argp is left pointing at the option
  257. X *    and argv and argc are adjusted accordingly if necessary.
  258. X *
  259. X *    Note that there is no check for missing option arguments.  In
  260. X *    particular, -o -V will blindly take -V as the output file name.
  261. X *
  262. X */
  263. X
  264. X#define XARG(argc,argv,argp) {if(*++argp=='\0'){argp=(*argv++);argc--;}}
  265. X
  266. Xstatic int parseCommandLine(argc,argv)
  267. Xint argc;
  268. Xchar **argv;
  269. X{
  270. X    register char *argp;    
  271. X
  272. X    DBUG_ENTER("parseCommandLine");
  273. X
  274. X    argc--;
  275. X    argv++;
  276. X    while(argc-- > 0){
  277. X    CHECK_ABORT;
  278. X
  279. X    argp=*argv++;
  280. X
  281. X    if(*argp=='+')
  282. X        options_SetByName(argp+1);
  283. X    else if(*argp!='-')    
  284. X        list_Add(ops,(void *)op_Create(argp));
  285. X    else
  286. X        switch(*++argp){
  287. X        case 'c':
  288. X            options_Clear(OPT_LINK);    /* don't link object modules */
  289. X            break;
  290. X        case 'p':            /* pass thru args to a pass */
  291. X            switch(*++argp){
  292. X            case '1':        /* pass 1 */
  293. X                XARG(argc,argv,argp);            
  294. X                list_Add(pass1PassThrus,argp);
  295. X                break;
  296. X            case '2':        /* pass 2 */
  297. X                XARG(argc,argv,argp);            
  298. X                list_Add(pass2PassThrus,argp);
  299. X                break;
  300. X            case 'o':        /* optimizer */
  301. X                XARG(argc,argv,argp);            
  302. X                list_Add(optPassThrus,argp);
  303. X                break;
  304. X            case 'l':        /* linking */
  305. X                XARG(argc,argv,argp);            
  306. X                list_Add(linkPassThrus,argp);
  307. X                break;
  308. X            default:
  309. X                fatal("unknown pass '%c'; must be one of [12ol]",argp[-1]);
  310. X            }
  311. X            break;
  312. X        case 'D':
  313. X            XARG(argc,argv,argp);
  314. X            list_Add(defines,(void *)argp);
  315. X            break;
  316. X        case 'E':
  317. X            warning("-E unimplemented, converted to -P instead");
  318. X            /* fall through */
  319. X        case 'P':
  320. X            options_Clear(OPT_COMPILE);
  321. X            options_Clear(OPT_ASSEMBLE);
  322. X            options_Clear(OPT_LINK);
  323. X            break;
  324. X        case 'g':
  325. X            if(*++argp!='\0') /* optional debuggin level */
  326. X            debugLevel=atoi(argp);
  327. X            options_Set(OPT_DEBUG);
  328. X            break;
  329. X        case 'I':
  330. X            XARG(argc,argv,argp);
  331. X            list_Add(incDirs,(void *)argp);
  332. X            break;
  333. X        case 'l':
  334. X            XARG(argc,argv,argp);
  335. X            list_Add(libs,(void *)argp);
  336. X            break;
  337. X        case 'L':
  338. X            XARG(argc,argv,argp);
  339. X            list_Add(libDirs,(void *)argp);
  340. X            break;
  341. X        case 'B':
  342. X            XARG(argc,argv,argp);
  343. X            list_Add(binDirs,(void *)argp);
  344. X            break;
  345. X        case 'O':
  346. X            options_Set(OPT_OPTIMIZE);
  347. X            break;
  348. X        case 'o':
  349. X            XARG(argc,argv,argp);
  350. X            outfile=argp;
  351. X            break;
  352. X        case 't':        /* warning, non-standard */
  353. X            XARG(argc,argv,argp);
  354. X            tempDir=argp;
  355. X            break;
  356. X        case 'S':
  357. X            warning("-S option not yet implemented, ignored");
  358. X            options_Clear(OPT_ASSEMBLE);
  359. X            break;
  360. X        case 'U':
  361. X            XARG(argc,argv,argp);
  362. X            list_Add(undefines,(void *)argp);
  363. X            break;
  364. X        default:
  365. X            fatal("unknown option '%c'",*argp);
  366. X            break;
  367. X        }
  368. X    }
  369. X
  370. X    DBUG_RETURN(int,list_GetLen(ops));
  371. X}
  372. X
  373. X/*
  374. X *    For each operand, do compilation or assembly as necessary, to
  375. X *    reduce to an object file in the current directory.
  376. X */
  377. Xstatic int makeObjs()
  378. X{
  379. X    int n;
  380. X    void **els;
  381. X    int numOps=list_GetLen(ops);
  382. X    int status=0;
  383. X
  384. X    DBUG_ENTER("makeObjs");
  385. X
  386. X    for(n=numOps,els=list_GetEls(ops); n>0; n--,els++){
  387. X    struct op *op=(struct op *)*els;
  388. X
  389. X    CHECK_ABORT;
  390. X
  391. X    if(numOps>1 && (op_IsC(op) || op_IsS(op)))
  392. X        printf("%s.%s:\n",op->rootname,op->suffix);
  393. X
  394. X    if(op_IsC(op))
  395. X        status=compile(op);
  396. X    else if(op_IsS(op))
  397. X        status=assemble(op);
  398. X    }
  399. X
  400. X    DBUG_RETURN(int,status);
  401. X}
  402. X
  403. X/* handy little routine */
  404. Xvoid addfList(ds,fmt,list)
  405. Xstruct dstr *ds;
  406. Xchar *fmt;
  407. Xstruct list *list;
  408. X{
  409. X    int n;
  410. X    void **els;
  411. X
  412. X    for(n=list_GetLen(list),els=list_GetEls(list); n>0; n--,els++)
  413. X    dstr_Addf(ds,fmt,(char *)*els);
  414. X}
  415. X
  416. X/*
  417. X *    Note that commands to cc of the form "-l<name>" get interpreted
  418. X *    to mean use a library called "name.lib" from the library
  419. X *    directory.
  420. X *      -lm is specially interpreted to be the appropriate math library.
  421. X */
  422. Xstatic int link()
  423. X{
  424. X    int n;
  425. X    void **els;
  426. X
  427. X    DBUG_ENTER("link");
  428. X
  429. X    dstr_Clear(cmdLine);
  430. X
  431. X    dstr_Addf(cmdLine,"%s ",locate("blink",binDirs));
  432. X
  433. X    if(options_IsSet(OPT_DETACH))
  434. X    dstr_Append(cmdLine,locate("cback.o",libDirs));
  435. X    else if(options_IsSet(OPT_RESIDENT)){
  436. X    if(options_IsSet(OPT_CATCH))
  437. X        dstr_Append(cmdLine,locate("catchres.o",libDirs));
  438. X    else
  439. X        dstr_Append(cmdLine,locate("cres.o",libDirs));
  440. X    }else if(options_IsSet(OPT_CATCH))
  441. X    dstr_Append(cmdLine,locate("catch.o",libDirs));
  442. X    else
  443. X    dstr_Append(cmdLine,locate("c.o",libDirs));
  444. X
  445. X    for(n=list_GetLen(ops),els=list_GetEls(ops); n>0; n--,els++){
  446. X    struct op *op=(struct op *)*els;
  447. X    char *name=(op_IsO(op) ? op->rootname : op->basename);
  448. X
  449. X    dstr_Addf(cmdLine,"+%s.o",name);
  450. X    }
  451. X
  452. X    if(options_IsSet(OPT_TINYMAIN))
  453. X    dstr_Addf(cmdLine," define __main=__tinymain ");
  454. X
  455. X    dstr_Addf(cmdLine," library ");
  456. X    for(n=list_GetLen(libs),els=list_GetEls(libs); n>0; n--,els++){
  457. X    char buffer[50];
  458. X    char *lib=(char *)*els;
  459. X
  460. X    if(strcmp(lib,"m")==0){
  461. X        /* map -lm to appropiate library */
  462. X
  463. X        strcpy(buffer,"lib:lcm");
  464. X
  465. X        if(options_IsSet(OPT_FFP))
  466. X            strcat(buffer,"ffp");
  467. X        else if(options_IsSet(OPT_IEEE))
  468. X         strcat(buffer,"ieee");
  469. X        else if(options_IsSet(OPT_881))
  470. X        strcat(buffer,"881");
  471. X
  472. X        /*
  473. X         * there are only r and s libraries for lcm.lib in the lattice
  474. X         * distribution; if there is a way to get the lcmieee, lcmffp,
  475. X         * & lcm881 libraries to work with reg-args & short-ints, I
  476. X         * couldn't find it.
  477. X         */
  478. X        if(options_IsSet(OPT_SHORTINTS))
  479. X            strcat(buffer,"s");
  480. X        if(options_IsSet(OPT_REGARGS))
  481. X            strcat(buffer,"r");
  482. X
  483. X        strcat(buffer,".lib");
  484. X    }else if(strcmp(lib,"lc")==0){
  485. X        /* do the standard c library */
  486. X
  487. X        strcpy(buffer,"lib:lc");
  488. X
  489. X        if(options_IsSet(OPT_SHORTINTS))
  490. X            strcat(buffer,"s");
  491. X        if(options_IsSet(OPT_REGARGS))
  492. X            strcat(buffer,"r");
  493. X        if(options_IsSet(OPT_ABSDATA))
  494. X            strcat(buffer,"nb");
  495. X
  496. X        strcat(buffer,".lib");
  497. X
  498. X        if(options_IsSet(OPT_REGARGS)){
  499. X            /*
  500. X             * Now, do it AGAIN, but without registers, to catch any missing refs.
  501. X             * I don't think this is exactly the right thing to do, but there seem
  502. X             * to be internal functions missing from the register-fied libraries
  503. X             */
  504. X
  505. X            strcat(buffer,"+lib:lc");
  506. X
  507. X            if(options_IsSet(OPT_SHORTINTS))
  508. X                strcat(buffer,"s");
  509. X            if(options_IsSet(OPT_ABSDATA))
  510. X                strcat(buffer,"nb");
  511. X
  512. X            strcat(buffer,".lib");
  513. X        }
  514. X    }else{
  515. X        sprintf(buffer,"%s.lib",lib);
  516. X        strcpy(buffer,locate(buffer,libDirs));
  517. X    }        
  518. X
  519. X        if(n==1)
  520. X        dstr_Append(cmdLine,buffer);
  521. X    else
  522. X        dstr_Addf(cmdLine,"%s+",buffer);
  523. X    }
  524. X
  525. X    if(outfile==NULL)
  526. X    /* there better be at least one source file! */
  527. X    outfile=((struct op *)list_GetEls(ops))->basename;
  528. X
  529. X    dstr_Addf(cmdLine," to %s map nil:",outfile);
  530. X
  531. X    addfList(cmdLine," %s",linkPassThrus);
  532. X
  533. X    DBUG_RETURN(int,runCmd(cmdLine));
  534. X}
  535. X
  536. X/*
  537. X *    compile one operand from a C source program to an object module.
  538. X */
  539. Xstatic int compile(op)
  540. Xstruct op *op;
  541. X{
  542. X    int status=0;
  543. X
  544. X    DBUG_ENTER("compile");
  545. X
  546. X    if(options_IsSet(OPT_ASSEMBLE)){
  547. X    status=pass1(op);
  548. X    if(status==0 && options_IsSet(OPT_COMPILE)){
  549. X        CHECK_ABORT;
  550. X        if(options_IsSet(OPT_OPTIMIZE))
  551. X        status=optimize(op);
  552. X        if(status==0)
  553. X            status=pass2(op);
  554. X    }
  555. X    }
  556. X
  557. X    DBUG_RETURN(int,status);
  558. X}
  559. X
  560. X/*
  561. X *    Note that because of brain-damage in the fact that -p to lc1 removes
  562. X *    all predefined defs, we must add them so replacing -c with -P in the
  563. X *    cc command line will result in the same set of predefined symbols.
  564. X *    This is rather ugly and leaves a hole for future problems if we
  565. X *    get out of sync with respect to what names the compiler predefines.
  566. X */
  567. Xstatic int pass1(op)
  568. Xregister struct op *op;
  569. X{
  570. X    char tmpFile[MAXPATH];
  571. X    int status;
  572. X    int n;
  573. X    void **els;
  574. X
  575. X    DBUG_ENTER("pass1");
  576. X
  577. X    dstr_Clear(cmdLine);
  578. X
  579. X    dstr_Append(cmdLine,locate((options_IsSet(OPT_BIGLC1) ? "lc1b" : "lc1"),binDirs));
  580. X
  581. X    if(options_IsSet(OPT_DEBUG)){
  582. X    dstr_Addf(cmdLine," -d%d",debugLevel);
  583. X    if(options_IsSet(OPT_OPTIMIZE)){
  584. X        warning("-g incompatible with -O, -O turned off");
  585. X        options_Clear(OPT_OPTIMIZE);
  586. X    }
  587. X    }
  588. X
  589. X    if(options_IsSet(OPT_FFP))
  590. X    dstr_Addf(cmdLine," -ff");
  591. X    else if(options_IsSet(OPT_881))
  592. X    dstr_Addf(cmdLine," -f8");
  593. X    else if(options_IsSet(OPT_IEEE))
  594. X    dstr_Addf(cmdLine," -fi");
  595. X    else
  596. X    dstr_Addf(cmdLine," -fl");
  597. X
  598. X    if(options_IsSet(OPT_SHORTINTS))
  599. X    dstr_Addf(cmdLine," -w");
  600. X    if(options_IsSet(OPT_LONGALIGN))
  601. X    dstr_Addf(cmdLine," -l");
  602. X
  603. X    if(options_IsSet(OPT_020))
  604. X    dstr_Addf(cmdLine," -m2");
  605. X    else if(options_IsSet(OPT_030))
  606. X    dstr_Addf(cmdLine," -m3");
  607. X
  608. X    if(options_IsSet(OPT_CATCH) && !options_IsSet(OPT_ABSDATA)){
  609. X    warning("+catch implies +abs-data");
  610. X    options_Set(OPT_ABSDATA);
  611. X    }
  612. X
  613. X    dstr_Addf(cmdLine," -b%d",options_IsSet(OPT_ABSDATA) ? 0 : 1);
  614. X    dstr_Addf(cmdLine," -r%d",options_IsSet(OPT_ABSCODE) ? 0 : 1);
  615. X
  616. X    if(options_IsSet(OPT_REGARGS))
  617. X    dstr_Addf(cmdLine,"r"); /* part of -r switch */
  618. X
  619. X    {
  620. X    char buf[15], *p=buf;
  621. X
  622. X    if(options_IsSet(OPT_ANSI))        *p++='a';
  623. X    if(options_IsSet(OPT_CPP))        *p++='+';
  624. X    if(options_IsSet(OPT_TRAD))        *p++='l', *p++='o';
  625. X    if(options_IsSet(OPT_REGARGS))        *p++='r';
  626. X    if(options_IsSet(OPT_PURESTRINGS))    *p++='s';
  627. X    
  628. X    if(p>buf){
  629. X        *p='\0';
  630. X        dstr_Addf(cmdLine," -c%s",buf);
  631. X    }
  632. X    }
  633. X
  634. X    if(options_IsSet(OPT_COMPILE)){
  635. X    strcpy(tmpFile,tempDir);
  636. X    strcat(tmpFile,op->basename);
  637. X    strcat(tmpFile,".q");
  638. X    dstr_Addf(cmdLine," -o%s",tmpFile);
  639. X    }else{
  640. X    strcpy(tmpFile,op->basename);
  641. X    strcat(tmpFile,".pp");
  642. X
  643. X    dstr_Addf(cmdLine," -o%s -p",tmpFile);
  644. X    }
  645. X
  646. X    for(n=list_GetLen(undefines),els=list_GetEls(undefines); n>0; n--,els++){
  647. X    /*************************
  648. X    dstr_Addf(cmdLine," -u%s",(char *)*els);
  649. X    **************************/
  650. X    warning("-U%s ignored! (unimplemented)",(char *)*els);
  651. X    }
  652. X
  653. X    addfList(cmdLine," -d%s",defines);
  654. X    addfList(cmdLine," %s",pass1PassThrus);
  655. X
  656. X    for(n=list_GetLen(incDirs),els=list_GetEls(incDirs); n>0; n--,els++){
  657. X    char *id=(*els);
  658. X    int len=strlen(id);
  659. X
  660. X    dstr_Addf(cmdLine," -i%s",*els);
  661. X
  662. X    if(len>0 && id[len-1]!=':' && id[len-1]!='/')
  663. X        dstr_Addf(cmdLine,"/");
  664. X    }
  665. X
  666. X    dstr_Addf(cmdLine," %s",op->rootname);
  667. X
  668. X    status=runCmd(cmdLine);
  669. X    if(status==0 && options_IsSet(OPT_EXEC) && !readable(tmpFile))
  670. X    status=1;
  671. X
  672. X    DBUG_RETURN(int,status);
  673. X}
  674. X
  675. X/* run the optimizer */
  676. Xstatic int optimize(op)
  677. Xstruct op *op;
  678. X{
  679. X    DBUG_ENTER("optimize");
  680. X
  681. X    dstr_Clear(cmdLine);
  682. X    dstr_Addf(cmdLine,"%s %s%s",locate("go",binDirs),tempDir,op->basename);
  683. X
  684. X    addfList(cmdLine," %s",optPassThrus);
  685. X
  686. X    DBUG_RETURN(int,runCmd(cmdLine));
  687. X}
  688. X
  689. X/*
  690. X *    Run second pass of compiler on a single operand.
  691. X */
  692. Xstatic int pass2(op)
  693. Xstruct op *op;
  694. X{
  695. X    char objFile[MAXPATH];
  696. X    int status;
  697. X
  698. X#ifdef DBUG
  699. X    fprintf(stderr,"Entering pass2...\n");
  700. X#endif
  701. X
  702. X    DBUG_ENTER("pass2");
  703. X
  704. X    dstr_Clear(cmdLine);
  705. X
  706. X    dstr_Append(cmdLine,locate("lc2",binDirs));
  707. X
  708. X    if(!options_IsSet(OPT_STACKCHECK))
  709. X    dstr_Addf(cmdLine," -v");
  710. X
  711. X    strcpy(objFile,op->basename);
  712. X    strcat(objFile,".o");
  713. X
  714. X    dstr_Addf(cmdLine," -o%s",objFile);
  715. X
  716. X    dstr_Addf(cmdLine," %s%s",tempDir,op->basename);
  717. X
  718. X    addfList(cmdLine," %s",pass2PassThrus);
  719. X
  720. X    status=runCmd(cmdLine);
  721. X    if(status==0 && options_IsSet(OPT_EXEC) && !readable(objFile))
  722. X    status=1;
  723. X
  724. X    DBUG_RETURN(int,status);
  725. X}
  726. X
  727. X/*
  728. X *    I have not yet had occasion to use the macro assembler,so this
  729. X *    part is not yet implemented.  If anyone wants to send me the
  730. X *    appropriate code, I will be glad to install it.
  731. X */
  732. Xstatic int assemble(op)
  733. Xstruct op *op;
  734. X{
  735. X    DBUG_ENTER("assemble");
  736. X    warning("assembly pass not yet implemented");
  737. X    DBUG_RETURN(int,1);
  738. X}
  739. X
  740. Xstatic void filteredOutputFrom(source,filter)
  741. XFILE *source;
  742. Xchar **filter;
  743. X{
  744. X    char buf[200];
  745. X
  746. X    DBUG_ENTER("FilteredOutputFrom");
  747. X
  748. X    while(!feof(source)){
  749. X    char **ignore;
  750. X
  751. X    fgets(buf,sizeof(buf),source);
  752. X
  753. X    for(ignore=filter; *ignore!=NULL; ignore++)
  754. X        if(strncmp(*ignore,buf,strlen(*ignore))==0)
  755. X            break;
  756. X
  757. X    if(*ignore==NULL)
  758. X        fputs(buf,stdout);
  759. X    }
  760. X
  761. X    DBUG_VOID_RETURN;
  762. X}
  763. X
  764. X#ifdef AMIGA
  765. X
  766. Xstatic int execToFile(cmd,sink)
  767. Xchar *cmd;
  768. XFILE *sink;
  769. X{
  770. X    /* this is a dopey version that uses Execute, since I can't get fork to work */
  771. X    long fh;
  772. X
  773. X    DBUG_ENTER("execToFile");
  774. X
  775. X    if(sink==NULL)
  776. X    fh=0;
  777. X    else
  778. X    fh=chkufb(fileno(sink))->ufbfh;
  779. X
  780. X    DBUG_RETURN(int,Execute(cmd,0L,fh)!=(-1));
  781. X
  782. X#if 0
  783. X    char *argv[50],**argp=argv;
  784. X    struct ProcID child;
  785. X    static struct FORKENV env={0,0,0,0,0,NULL};
  786. X    int i;
  787. X
  788. X    DBUG_ENTER("execToFile");
  789. X
  790. X    if(cmd==NULL)
  791. X        DBUG_RETURN(int,1);
  792. X
  793. X    /* this is sort of stupid, cause forkv will just put them back together,
  794. X     * but oh well...
  795. X     */
  796. X    *argp=strtok(cmd," \t");
  797. X    while(*argp!=NULL)
  798. X        *++argp=strtok(NULL," \t");
  799. X
  800. X    if(sink==NULL)
  801. X        env.std_out=0;
  802. X    else{
  803. X        struct UFB *ufb=chkufb(fileno(sink));
  804. X    int i;
  805. X
  806. X    printf("argv[%d]:",argp-argv);
  807. X    for(argp=argv;*argp!=NULL;argp++)
  808. X        printf(" %s",*argp);
  809. X    putchar('\n');
  810. X
  811. X    printf("env: %d, %d, %d, %d, %d, %d\n",
  812. X        env.priority, env.stack, env.std_in, env.std_out,
  813. X        env.console, env.msgport);
  814. X
  815. X    printf("ufb==0x%x, fh==0x%x, go? ",ufb,ufb->ufbfh);
  816. X
  817. X    fflush(stdout);
  818. X
  819. X    env.std_out=ufb->ufbfh; /* magic to get amigados handle from FILE */
  820. X    }
  821. X
  822. X    if((i=forkv(argv[0],argv,&env,&child))==-1){
  823. X        poserr("forkv");
  824. X        DBUG_RETURN(int,1);
  825. X    }
  826. X
  827. X    printf("Fork returns: %d\n",i);
  828. X
  829. X    DBUG_RETURN(int,wait(&child));
  830. X#endif
  831. X}
  832. X
  833. X#endif
  834. X 
  835. Xstatic int runCmd(cmd)
  836. Xstruct dstr *cmd;
  837. X{
  838. X    int status;
  839. X    char *buf=dstr_GetBuf(cmd);
  840. X    
  841. X    DBUG_ENTER("RunCommand");
  842. X
  843. X    DBUG_3("cmd","execute '%s'",buf);
  844. X    if(options_IsSet(OPT_ECHO)){
  845. X    puts(buf);
  846. X    fflush(stdout);
  847. X    }
  848. X
  849. X    CHECK_ABORT;
  850. X
  851. X    if(options_IsSet(OPT_EXEC)){
  852. X    FILE *sink;
  853. X
  854. X    if(sinkFile!=NULL && options_IsSet(OPT_FILTER)){
  855. X        sink=fopen(sinkFile,"w+");
  856. X        if(sink==NULL)
  857. X        perror(sinkFile);
  858. X    }else
  859. X        sink=NULL;
  860. X
  861. X    status=execToFile(buf,sink);
  862. X    DBUG_3("sys","subcommand returns status %d",status);
  863. X
  864. X    if(sink!=NULL){
  865. X        rewind(sink);
  866. X        filteredOutputFrom(sink,filteredPrefixes);
  867. X        fclose(sink);
  868. X        unlink(sinkFile);
  869. X    }
  870. X
  871. X    DBUG_RETURN(int,status);
  872. X    }else
  873. X    DBUG_RETURN(int,0);
  874. X}
  875. X
  876. X/*
  877. X *    Look through the list of paths pointed to by "vec" until we find
  878. X *    a file with name given pointed to by "namep".  If none is found,
  879. X *    the name pointed to by namep is returned.
  880. X */
  881. Xstatic char *locate(name,paths)
  882. Xchar *name;
  883. Xstruct list *paths;
  884. X{
  885. X    static char namebuf[MAXPATH];
  886. X    void **els;
  887. X    int n;
  888. X    
  889. X    DBUG_ENTER("locate");
  890. X
  891. X    if(strchr(name,':')!=NULL || *name=='/')
  892. X    return name;    /* absolute */
  893. X    
  894. X    for(n=list_GetLen(paths),els=list_GetEls(paths); n>0; n--,els++){
  895. X    int len=strlen((char *)*els);
  896. X
  897. X    strcpy(namebuf,(char *)*els);
  898. X    if(len>0 && namebuf[len-1]!=':' && namebuf[len-1]!='/')
  899. X        strcat(namebuf,"/");
  900. X    strcat(namebuf,name);
  901. X
  902. X    DBUG_3("try","look for '%s'",namebuf);
  903. X    if(readable(namebuf)){
  904. X        name=namebuf;
  905. X        break;
  906. X    }
  907. X    }
  908. X
  909. X    DBUG_RETURN(char *,name);
  910. X}
  911. X
  912. X/*
  913. X *    Check to see if the file exists and is readable.
  914. X */
  915. Xstatic int readable(name)
  916. Xchar *name;
  917. X{
  918. X    register int status=0;
  919. X    register long fildes;
  920. X    
  921. X    DBUG_ENTER("readable");
  922. X
  923. X#ifdef unix
  924. X    fildes=open(name,O_RDONLY);
  925. X    if(fildes >= 0){
  926. X    (void) close(fildes);
  927. X    status=1;
  928. X    }
  929. X#else
  930. X    fildes=Lock(name,ACCESS_READ);
  931. X    if(fildes != 0){
  932. X        UnLock(fildes);
  933. X    status=1;
  934. X    }
  935. X#endif
  936. X
  937. X    DBUG_RETURN(int,status);
  938. X}
  939. X
  940. X/*
  941. X *    If an executable is made from a single C file, the normal behavior
  942. X *    for the unix environment is to treat the .o file as an intermediate
  943. X *    file and remove it, so we follow suit.
  944. X */
  945. Xstatic void cleanObjects(mustExist)
  946. Xint mustExist;
  947. X{
  948. X    int n;
  949. X    void **els;
  950. X
  951. X    DBUG_ENTER("cleanObjects");
  952. X    
  953. X    for(n=list_GetLen(ops),els=list_GetEls(ops); n>0; n--,els++){
  954. X    char buf[MAXPATH];
  955. X        struct op *op=(struct op *)*els;
  956. X
  957. X    if(!op_IsO(op)){
  958. X        strcpy(buf,op->basename);
  959. X        strcat(buf,".o");
  960. X        if(unlink(buf)!=0 && mustExist)
  961. X            warning("can't delete '%s'",buf);
  962. X        }
  963. X    }
  964. X
  965. X    DBUG_VOID_RETURN;
  966. X}
  967. SHAR_EOF
  968. echo "extracting cc.doc"
  969. sed 's/^X//' << \SHAR_EOF > cc.doc
  970. X    CC: a unix-like compiler driver for amiga lattice-c (that also
  971. X        filters out stupid messages!)
  972. X
  973. X    USAGE:
  974. X    cc [args] file...
  975. X
  976. X      Arguments are ([x] means x is optional):
  977. X
  978. X    file        A file to compile or link.  Currently, only .c and .o
  979. X            are understood, although supporting .s files would
  980. X            probably be pretty simple.
  981. X
  982. X    -o execfile    Write the resulting executable to EXECFILE (only
  983. X            meaningful when linking).
  984. X
  985. X    -c        Don't link the object file, just leave it there.
  986. X
  987. X    -g[num]        Compile in debugging info, using debug-level NUM.
  988. X    -O        Use the global optimizer (incompatible with -g).
  989. X    -P        Just pre-process the file, creating a .pp file.
  990. X
  991. X    -l libname    Add LIBNAME.lib to the list of libraries.
  992. X
  993. X    -I dir        Add the directory DIR to the path searched for include
  994. X            files.
  995. X    -D define    Add DEFINE a pre-processor define; it can be just a name
  996. X            or name=value.
  997. X    -U undefin    Undefine the symbol UNDEFINE (this really doesn't work).
  998. X    -L libdir    Add the directory LIBDIR to the path searched for
  999. X            libraries.
  1000. X    -B bindir    Add the directory BINDIR to the path searched for
  1001. X            binaries.
  1002. X
  1003. X    -px string    Put STRING on the command line of compiler pass X, where
  1004. X            X is one of: 1-- pass1; 2-- pass2; o-- optimizer;
  1005. X            and l-- linker.  This switch can be used to get at
  1006. X            compiler features that cc doesn't directly support,
  1007. X            although it'd be better to just add the feature to cc
  1008. X            (it shouldn't be too hard)-- and send the change
  1009. X            back to me (bader+@andrew.cmu.edu)!
  1010. X
  1011. X    -t tempdir    Use TEMPDIR as the place to put temporary files.
  1012. X
  1013. X    +ansi            Enforce ansi fascism.
  1014. X    +cpp            Compat with c++.
  1015. X    +trad            Use traditional style cpp.
  1016. X
  1017. X    +[no-]abs-code        Use long (absolute) addressing for function
  1018. X                calls.
  1019. X    +[no-]abs-data        Use long (absolute) addressing for data.
  1020. X
  1021. X    +[no-]reload-a4        Reload reg a4 in each function.
  1022. X    +[no-]short-ints    Use short integers.
  1023. X    +[no-]reg-args        Use register argument passing.
  1024. X    +[no-]long-align    Align everything to long boundaries.
  1025. X    +[no-]stack-check    Put stack-checking into the func prolog.
  1026. X    +[no-]pure-strings    Put strings in the text segment.
  1027. X
  1028. X    +ffp            Use motorola fast floating point.
  1029. X    +881            Compile for a 68881.
  1030. X    +ieee            Ieee floating point.
  1031. X
  1032. X    +68k            Compile for a 68000 and up.
  1033. X    +020            Compile for a 68020 and up.
  1034. X    +030            Compile for a 68030.
  1035. X
  1036. X    +[no-]detach        Make a program that runs in the background.
  1037. X    +[no-]tiny-main        Use tinymain (this doesn't work).
  1038. X    +[no-]resident        Try and make resident-able.
  1039. X    +[no-]catch        Compile in code to try and catch exceptions.
  1040. X
  1041. X    +[no-]optimize        Optimize the obj module.
  1042. X    +[no-]link        Link the object modules.
  1043. X    +[no-]compile        (Otherwise, just pre-process).
  1044. X    +[no-]assemble        Emit object-modules (else assembly).
  1045. X    +[no-]debug        Produce debugging info.
  1046. X
  1047. X    +[no-]echo        Echo what we execute.
  1048. X    +[no-]filter        Filter out yucky message from passes.
  1049. X    +[no-]exec        Actually run each pass.
  1050. X
  1051. X    +[no-]big-lc1        Run lc1b instead of lc1.
  1052. X
  1053. X    DEFAULTS:
  1054. X        The default options are: +compile +link +stack-check +exec +filter
  1055. X
  1056. X    The default output file is "a.out".
  1057. X
  1058. X    The default temp directory is "t:".
  1059. X
  1060. X    The default debug level when just -g (or +debug) is specified is 3.
  1061. X
  1062. X    The default libraries are: "-lc", "-lamiga".
  1063. X
  1064. X    NOTES:
  1065. X    The library -lm is replaced by whichever math library is appropiate
  1066. X    given other switches (like +ieee or +ffp), and -lc is replaced by
  1067. X    the appropiate c library-- so be and sure to pass the same set of
  1068. X    switches to cc when linking as you do when compiling (with -c) the
  1069. X    object files!
  1070. X
  1071. X    This version of cc is intended for use with lattice c version 5.
  1072. X
  1073. X    BUGS:
  1074. X    I haven't nearly tested all the possible combinations of options.
  1075. X
  1076. X    The libraries supplied by lattice aren't complete, so some combos
  1077. X    of switches may not be possible (e.g., +reg-args and +ieee-- lattice
  1078. X    doesn't supply a libieeer.lib, and so linking fails in this case).
  1079. X
  1080. X    -U doesn't work.
  1081. X
  1082. X    -S doesn't work (and isn't ever likely too unless lattice makes
  1083. X    omd a much better program).
  1084. X
  1085. X    Compiling .s (assembly) files isn't implemented, even though it's
  1086. X    probably pretty simple, using asm.  I just never needed it...
  1087. X
  1088. X    AUTHOR:
  1089. X    Miles Bader (bader+@andrew.cmu.edu)
  1090. X       from an earlier program by Fred Fish.
  1091. SHAR_EOF
  1092. echo "extracting config.h"
  1093. sed 's/^X//' << \SHAR_EOF > config.h
  1094. X/*
  1095. X * configuration file for cc; easily re-configurable stuff goes here.
  1096. X * March 1989, Miles Bader
  1097. X */
  1098. X
  1099. X/*
  1100. X * this file contains declarations, so it can only be included in one source file
  1101. X */
  1102. X
  1103. X#define MAXPATH 200        /* max length of a path */
  1104. X
  1105. X/* What to call executable if not specified.  If NULL, named after 1st source file */
  1106. X#define DEFAULT_EXEC "a.out"
  1107. X 
  1108. X/* must be a prefix; i.e., needs a slash or a colon on the end */
  1109. X#define TEMPDIR    "T:"        /* Keep intermediate files in temp directory */
  1110. X/* #define TEMPDIR "" */    /* Keep intermediate files in current dir */
  1111. X
  1112. X/* The file for filtering compiler pass output.  If NULL, no filtering is done */
  1113. X#define SINKFILE "T:__cc_sink"
  1114. X
  1115. X#define DEFAULT_DEBUGLEVEL 3    /* default debug level if just -g is given */
  1116. X
  1117. X/* Listf of default options.  Note that not having _EXEC, _COMPILE, _ASSEMBLE,
  1118. X * and _LINK set by default would be very wierd
  1119. X */
  1120. Xint defaultOptions[]={
  1121. X    OPT_COMPILE,    /* compile things! */
  1122. X    OPT_ASSEMBLE,    /* make object files! */
  1123. X    OPT_EXEC,        /* execute passes! */
  1124. X    OPT_LINK,        /* link into executable! */
  1125. X    OPT_FILTER,        /* filter out obnoxious messages */
  1126. X    OPT_STACKCHECK,    /* enable stack checking */
  1127. X    0
  1128. X};
  1129. X
  1130. X/* initial contents of some lists; &insertMark is where additional elements go */
  1131. Xchar *libDirsInit[]={"",&insertMark,"lib:",NULL};
  1132. Xchar *incDirsInit[]={&insertMark,"include:",NULL};
  1133. Xchar **binDirsInit=NULL;
  1134. Xchar **definesInit=NULL;
  1135. Xchar **undefinesInit=NULL;
  1136. Xchar *libsInit[]={&insertMark,"lc","amiga",NULL};
  1137. X
  1138. X/* prefixes that are filtered out of the compiler output stream */
  1139. Xchar *filteredPrefixes[]={
  1140. X    "\n",            /* blank lines */
  1141. X    "Copyright",        /* copyright noticed */
  1142. X    "Lattice",            /* lattice advertisements */
  1143. X
  1144. X    /* lc2 */
  1145. X    "Module size",
  1146. X
  1147. X    /* blink */
  1148. X    "Blink - Version",
  1149. X    "Enter a DEFINE value",     /* input is impossible anyway... */
  1150. X    "BLINK Complete",
  1151. X    "Final output file size",
  1152. X    NULL
  1153. X};
  1154. SHAR_EOF
  1155. echo "extracting dstr.c"
  1156. sed 's/^X//' << \SHAR_EOF > dstr.c
  1157. X/*
  1158. X * dynamic strings
  1159. X * March 1989, Miles Bader
  1160. X */
  1161. X
  1162. X#include "common.h"
  1163. X#include "dstr.h"
  1164. X
  1165. Xstruct dstr *dstr_Create(initsize)
  1166. Xint initsize;
  1167. X{
  1168. X    struct dstr *n=NEW(struct dstr);
  1169. X    
  1170. X    DBUG_ENTER("dstr_Create");
  1171. X
  1172. X    if(n==NULL)
  1173. X    fatal("couldn't allocate a dstr");
  1174. X
  1175. X    n->buf=malloc(initsize+1);
  1176. X
  1177. X    if(n->buf==NULL)
  1178. X    fatal("couldn't allocate dstr of size %d",initsize);
  1179. X
  1180. X    n->max=initsize;
  1181. X    n->len=0;
  1182. X    *n->buf='\0';
  1183. X
  1184. X    DBUG_RETURN(struct dstr *,n);
  1185. X}
  1186. X
  1187. Xvoid dstr_Free(ds)
  1188. Xstruct dstr *ds;
  1189. X{
  1190. X    DBUG_ENTER("dstr_Free");
  1191. X
  1192. X    if(ds->buf!=NULL)
  1193. X    FREE(ds->buf);
  1194. X    FREE(ds);
  1195. X
  1196. X    DBUG_VOID_RETURN;
  1197. X}
  1198. X
  1199. Xvoid dstr_Clear(ds)
  1200. Xstruct dstr *ds;
  1201. X{
  1202. X   ds->len=0;
  1203. X   *ds->buf='\0';
  1204. X}
  1205. X
  1206. Xvoid dstr_Append(ds,str)
  1207. Xstruct dstr *ds;
  1208. Xchar *str;
  1209. X{
  1210. X    int len=strlen(str);
  1211. X    
  1212. X    DBUG_ENTER("dstr_Append");
  1213. X
  1214. X    if(len+ds->len>ds->max){
  1215. X    ds->max+=len+len;
  1216. X    ds->buf=(char *)realloc((void *)ds->buf,ds->max);
  1217. X
  1218. X    if(ds->buf==NULL)
  1219. X        fatal("couldn't extend a dstr to %d chars",ds->max);
  1220. X    }
  1221. X
  1222. X    strcpy(ds->buf+ds->len,str);
  1223. X    ds->len+=len;
  1224. X
  1225. X    DBUG_VOID_RETURN;
  1226. X}
  1227. X
  1228. Xvoid dstr_Set(ds,str)
  1229. Xstruct dstr *ds;
  1230. Xchar *str;
  1231. X{
  1232. X    DBUG_ENTER("dstr_Set");
  1233. X
  1234. X    ds->len=0;
  1235. X    dstr_Append(ds,str);
  1236. X
  1237. X    DBUG_VOID_RETURN;
  1238. X}
  1239. X
  1240. Xvoid dstr_Addf(ds,fmt,a1,a2,a3,a4,a5,a6,a7)
  1241. Xstruct dstr *ds;
  1242. Xchar *fmt;
  1243. Xchar *a1,*a2,*a3,*a4,*a5,*a6,*a7;
  1244. X{
  1245. X    char buf[500];
  1246. X
  1247. X    DBUG_ENTER("dstr_Addf");
  1248. X
  1249. X    sprintf(buf,fmt,a1,a2,a3,a4,a5,a6,a7);
  1250. X
  1251. X    DBUG_2("buf",buf);
  1252. X
  1253. X    dstr_Append(ds,buf);
  1254. X
  1255. X    DBUG_VOID_RETURN;
  1256. X}
  1257. SHAR_EOF
  1258. echo "extracting dstr.h"
  1259. sed 's/^X//' << \SHAR_EOF > dstr.h
  1260. X/*
  1261. X * dynamic strings
  1262. X * March 1989, Miles Bader
  1263. X */
  1264. X
  1265. Xstruct dstr {
  1266. X    int max,len;
  1267. X    char *buf;
  1268. X};
  1269. X
  1270. Xstruct dstr *dstr_Create();
  1271. Xvoid dstr_Free();
  1272. Xvoid dstr_Clear();
  1273. Xvoid dstr_Set();
  1274. Xvoid dstr_Append();
  1275. Xvoid dstr_Addf();
  1276. X
  1277. X#define dstr_GetBuf(d) ((d)->buf)
  1278. X#define dstr_GetLen(d) ((d)->len)
  1279. SHAR_EOF
  1280. echo "extracting err.c"
  1281. sed 's/^X//' << \SHAR_EOF > err.c
  1282. X/*
  1283. X * these are in a separate file so the compiler doesn't bitch about mismatched
  1284. X * arguments
  1285. X */
  1286. X
  1287. X#include <stdio.h>
  1288. X
  1289. X#include "common.h"
  1290. X
  1291. X/*VARARGS1*/
  1292. Xvoid warning(fmt,a1,a2,a3,a4,a5,a6,a7)
  1293. Xchar *fmt;
  1294. Xchar *a1,*a2,*a3,*a4,*a5,*a6,*a7;
  1295. X{
  1296. X    fputs("cc: warning: ",stderr);
  1297. X    fprintf(stderr,fmt,a1,a2,a3,a4,a5,a6,a7);
  1298. X    putc('\n',stderr);
  1299. X    (void) fflush(stderr);
  1300. X}
  1301. X
  1302. X/*VARAS1*/
  1303. Xvoid fatal(fmt,a1,a2,a3,a4,a5,a6,a7)
  1304. Xchar *fmt;
  1305. Xchar *a1,*a2,*a3,*a4,*a5,*a6,*a7;
  1306. X{
  1307. X    fputs("cc: error: ",stderr);
  1308. X    fprintf(stderr,fmt,a1,a2,a3,a4,a5,a6,a7);
  1309. X    putc('\n',stderr);
  1310. X    (void) fflush(stderr);
  1311. X    exit(1);
  1312. X}
  1313. SHAR_EOF
  1314. echo "extracting list.c"
  1315. sed 's/^X//' << \SHAR_EOF > list.c
  1316. X/*
  1317. X * expandable lists
  1318. X * March 1989, Miles Bader
  1319. X */
  1320. X
  1321. X#include "common.h"
  1322. X#include "list.h"
  1323. X
  1324. X#define BUMPSIZE 5            /* grow list this much at a time */
  1325. X
  1326. Xchar insertMark;            /* dummy used for its address */
  1327. X
  1328. Xstruct list *list_Create(init)
  1329. Xvoid **init;
  1330. X{
  1331. X    void **p,**q;
  1332. X    struct list *l=NEW(struct list);
  1333. X    
  1334. X    DBUG_ENTER("list_Create");
  1335. X
  1336. X    if(l==NULL)
  1337. X    fatal("couldn't allocate a list");
  1338. X
  1339. X    l->num=0;
  1340. X
  1341. X    l->insertionPoint=(-1);
  1342. X
  1343. X    for(p=init; p!=NULL && *p!=NULL; p++)
  1344. X    if(*p==&insertMark)
  1345. X        l->insertionPoint=l->num;
  1346. X    else
  1347. X        l->num++;
  1348. X
  1349. X    l->els=(void **)malloc(l->num*sizeof(void *));
  1350. X
  1351. X    if(l->els==NULL && l->num>0 /* ANSI compat */)
  1352. X    fatal("couldn't allocate initial list elements");
  1353. X
  1354. X    for(p=init,q=l->els; p!=NULL && *p!=NULL; p++)
  1355. X    if(*p!=&insertMark)
  1356. X        *q++=(*p);
  1357. X
  1358. X    l->max=l->num;
  1359. X    if(l->insertionPoint<0)
  1360. X    l->insertionPoint=l->num;     /* default is at end */
  1361. X
  1362. X    l->freeProc=NULL;
  1363. X
  1364. X    DBUG_RETURN(struct list *,l);
  1365. X}
  1366. X
  1367. Xvoid list_Free(l)
  1368. Xstruct list *l;
  1369. X{
  1370. X    DBUG_ENTER("list_Free");
  1371. X
  1372. X    if(l->freeProc!=NULL){
  1373. X        void **els;
  1374. X    int n;
  1375. X    
  1376. X    DBUG_4("free","using freeProc on %d els: 0x%x",l->num,l->freeProc);
  1377. X
  1378. X    for(n=l->num,els=l->els; n>0; n--,els++){
  1379. X        DBUG_3("free","freeProc(0x%x)",*els);
  1380. X        (*l->freeProc)(*els);
  1381. X    }
  1382. X    }
  1383. X
  1384. X    if(l->els!=NULL){
  1385. X        DBUG_3("free","freeing els: 0x%x",l->els);
  1386. X    FREE(l->els);
  1387. X    }
  1388. X
  1389. X    DBUG_3("free","freeing list: 0x%x",l);
  1390. X
  1391. X    FREE(l);
  1392. X
  1393. X    DBUG_VOID_RETURN;
  1394. X}
  1395. X
  1396. Xvoid list_Add(l,e)
  1397. Xstruct list *l;
  1398. Xvoid *e;
  1399. X{
  1400. X    int i;
  1401. X    
  1402. X    DBUG_ENTER("list_Add");
  1403. X
  1404. X    if(l->num>=l->max){
  1405. X        l->max+=BUMPSIZE;
  1406. X    l->els=(void **)realloc((void *)l->els,l->max*sizeof(void *));
  1407. X
  1408. X    if(l->els==NULL)
  1409. X        fatal("couldn't extend a list to %d elements",l->max);
  1410. X    }
  1411. X
  1412. X    for(i=l->num; i>l->insertionPoint; i--)
  1413. X    l->els[i]=l->els[i-1];
  1414. X
  1415. X    l->els[l->insertionPoint++]=e;
  1416. X
  1417. X    l->num++;
  1418. X
  1419. X    DBUG_VOID_RETURN;
  1420. X}
  1421. SHAR_EOF
  1422. echo "extracting list.h"
  1423. sed 's/^X//' << \SHAR_EOF > list.h
  1424. X/*
  1425. X * expandable lists
  1426. X * March 1989, Miles Bader
  1427. X */
  1428. X
  1429. Xextern char insertMark;
  1430. X
  1431. Xstruct list {
  1432. X    int num,max;
  1433. X    int insertionPoint;            /* where a new element gets added */
  1434. X    void **els;
  1435. X    void (*freeProc)();            /* if non-NULL, used to free elements */
  1436. X};
  1437. X
  1438. Xstruct list *list_Create(void **initEls);
  1439. Xvoid list_Free(struct list *l);
  1440. Xvoid list_Add(struct list *l,void *el);
  1441. X
  1442. X#define list_GetEls(l) ((l)->els)
  1443. X#define list_GetLen(l) ((l)->num)
  1444. X
  1445. X#define list_SetFree(l,fp) ((l)->freeProc=fp)
  1446. SHAR_EOF
  1447. echo "extracting op.c"
  1448. sed 's/^X//' << \SHAR_EOF > op.c
  1449. X/*
  1450. X * file operands
  1451. X * March 1989, Miles Bader (orig from cc.c by fred fish)
  1452. X */
  1453. X
  1454. X#include "common.h"
  1455. X#include "op.h"
  1456. X
  1457. X/*
  1458. X *    Split an operand name into rootname, basename, and suffix
  1459. X *    components.  The rootname is the full name, minus any suffix,
  1460. X *    but including any prefix.  The basename is the rootname minus
  1461. X *    any prefix.  The suffix is anything after the last '.' character.
  1462. X *    Only the suffix is allowed to be the null string.
  1463. X */
  1464. Xstruct op *op_Create(filename)
  1465. Xchar *filename;
  1466. X{
  1467. X    char *split;
  1468. X    extern char *strrchr();
  1469. X    struct op *op=NEW(struct op);
  1470. X
  1471. X    DBUG_ENTER("op_Create");
  1472. X
  1473. X    DBUG_3("ops", "create op '%s'",filename);
  1474. X
  1475. X    if(op==NULL)
  1476. X    fatal("couldn't allocate an op");
  1477. X
  1478. X    op->rootname=filename;
  1479. X
  1480. X    split=strrchr(filename,'/');
  1481. X    if(split==NULL)
  1482. X    split=strrchr(filename,':');
  1483. X
  1484. X    if(split==NULL)
  1485. X    op->basename=filename;
  1486. X    else
  1487. X    op->basename=++split;
  1488. X
  1489. X    split=strrchr(filename,'.');
  1490. X    if(split==NULL)
  1491. X    op->suffix="";
  1492. X    else{
  1493. X    *split++='\0';
  1494. X    op->suffix=split;
  1495. X    }
  1496. X
  1497. X    DBUG_3("ops","rootname '%s'",op->rootname);
  1498. X    DBUG_3("ops","basename '%s'",op->basename);
  1499. X    DBUG_3("ops","suffix '%s'",op->suffix);
  1500. X
  1501. X    DBUG_RETURN(struct op *,op);
  1502. X}
  1503. X
  1504. Xvoid op_Free(op)
  1505. Xstruct op *op;
  1506. X{
  1507. X    FREE(op);
  1508. X}
  1509. SHAR_EOF
  1510. echo "extracting op.h"
  1511. sed 's/^X//' << \SHAR_EOF > op.h
  1512. X/*
  1513. X * file operands
  1514. X * March 1989, Miles Bader (orig from cc.c by fred fish)
  1515. X */
  1516. X
  1517. X/*
  1518. X *    Command line arguments that represent files to be compiled, assembled,
  1519. X *    or linked, are kept track of as "ops".  If, for example,
  1520. X *    the file name is "df0:mydir/junk.c", then the rootname is
  1521. X *    "df0:mydir/junk", the basename is "junk", and the suffix is "c".
  1522. X *    String suffixes are used, rather than single character suffixes, to
  1523. X *    allow use of names with multicharacter suffixes.
  1524. X */
  1525. X
  1526. Xstruct op{        /* Info about each operand (non option) */
  1527. X    char *rootname;        /* Name minus any suffix */
  1528. X    char *basename;        /* Name minus any prefix or suffix */
  1529. X    char *suffix;        /* suffix of operand */
  1530. X};
  1531. X
  1532. X/*
  1533. X *    macros to determine the suffix type of a file given a pointer to
  1534. X *    its operand structure.
  1535. X */
  1536. X#define op_IsC(op) (strcmp(op->suffix,"c")==0)
  1537. X#define op_IsS(op) (strcmp(op->suffix,"s")==0)
  1538. X#define op_IsO(op) (strcmp(op->suffix,"o")==0)
  1539. X
  1540. Xstruct op *op_Create(char *name);
  1541. Xvoid op_Free(struct op *op);
  1542. SHAR_EOF
  1543. echo "extracting options.c"
  1544. sed 's/^X//' << \SHAR_EOF > options.c
  1545. X/*
  1546. X * compiler options processing
  1547. X * March 1989, Miles Bader
  1548. X */
  1549. X
  1550. X#include "common.h"
  1551. X#include "options.h"
  1552. X
  1553. Xlong globalOpts[MAXOPTS/BITSPERLONG];
  1554. X
  1555. Xstruct option {
  1556. X    char *name;
  1557. X    int opt;
  1558. X    int *set;
  1559. X};
  1560. X
  1561. X/* pre-processor compatibility modes */
  1562. Xint ppOptSet[]={OPT_TRAD, OPT_ANSI, OPT_CPP, 0};
  1563. X
  1564. X/* cpu-types */
  1565. Xint cpuOptSet[]={OPT_68K, OPT_020, OPT_030, 0};
  1566. X
  1567. X/* types of floating point support */
  1568. Xint floatOptSet[]={OPT_FFP, OPT_IEEE, OPT_881, 0};
  1569. X
  1570. Xstruct option optionlist[]={
  1571. X/*   name        mask        excludes    */
  1572. X
  1573. X    /* parsing */
  1574. X    {"ansi",        OPT_ANSI,    ppOptSet},
  1575. X    {"c++",        OPT_CPP,    ppOptSet},
  1576. X    {"traditional",    OPT_TRAD,    ppOptSet},
  1577. X
  1578. X    /* code gen */
  1579. X    {"abs-code",    OPT_ABSCODE},
  1580. X    {"abs-data",    OPT_ABSDATA},
  1581. X
  1582. X    {"reg-args",    OPT_REGARGS},
  1583. X    {"reload-a4",    OPT_RELOADA4},
  1584. X    {"short-ints",    OPT_SHORTINTS},
  1585. X    {"long-align",    OPT_LONGALIGN},
  1586. X    {"stack-check",    OPT_STACKCHECK},
  1587. X
  1588. X    {"pure-strings",    OPT_PURESTRINGS},
  1589. X
  1590. X    {"68k",        OPT_68K,    cpuOptSet},
  1591. X    {"020",        OPT_020,    cpuOptSet},
  1592. X    {"030",        OPT_030,    cpuOptSet},
  1593. X
  1594. X    {"881",        OPT_881,    floatOptSet},
  1595. X    {"ffp",        OPT_FFP,    floatOptSet},
  1596. X    {"ieee",        OPT_IEEE,    floatOptSet},
  1597. X
  1598. X    /* linking */
  1599. X    {"detach",        OPT_DETACH},
  1600. X    {"resident",    OPT_RESIDENT},
  1601. X    {"tiny-main",    OPT_TINYMAIN},
  1602. X    {"catch",        OPT_CATCH},
  1603. X
  1604. X    {"optimize",    OPT_OPTIMIZE},
  1605. X    {"link",        OPT_LINK},
  1606. X    {"compile",        OPT_COMPILE},
  1607. X    {"assemble",    OPT_ASSEMBLE},
  1608. X    {"debug",        OPT_DEBUG},
  1609. X
  1610. X    {"echo",        OPT_ECHO},
  1611. X    {"filter",        OPT_FILTER},
  1612. X    {"exec",        OPT_EXEC},
  1613. X
  1614. X    {"big-lc1",        OPT_BIGLC1},
  1615. X
  1616. X    NULL
  1617. X};
  1618. X
  1619. Xvoid options_SetByName(optname)
  1620. Xchar *optname;
  1621. X{
  1622. X    struct option *opt;
  1623. X    int not=FALSE;
  1624. X
  1625. X    if(strncmp(optname,"no-",3)==0){
  1626. X    optname+=3;
  1627. X    not=TRUE;
  1628. X    }
  1629. X
  1630. X    for(opt=optionlist; opt->name!=NULL; opt++)
  1631. X    if(strcmp(optname,opt->name)==0){
  1632. X        if(not){
  1633. X        if(opt->set!=NULL)
  1634. X            fatal("%s is not a boolean option",opt);
  1635. X        else
  1636. X            options_Clear(opt->opt);
  1637. X        }else{
  1638. X        if(opt->set!=NULL){
  1639. X            int *clear;
  1640. X            for(clear=opt->set; *clear!=0; clear++)
  1641. X                options_Clear(*clear);
  1642. X        }
  1643. X        
  1644. X        options_Set(opt->opt);
  1645. X        }
  1646. X
  1647. X        break;
  1648. X    }
  1649. X
  1650. X    if(opt->name==NULL)
  1651. X    fatal("unknown option: %s",optname);
  1652. X}
  1653. X
  1654. Xvoid options_Init()
  1655. X{
  1656. X    int i;
  1657. X    for(i=0; i<(MAXOPTS/BITSPERLONG); i++)
  1658. X    globalOpts[i]=0;
  1659. X}
  1660. SHAR_EOF
  1661. echo "extracting options.h"
  1662. sed 's/^X//' << \SHAR_EOF > options.h
  1663. X/*
  1664. X * compiler options
  1665. X * March 1989, Miles Bader
  1666. X */
  1667. X
  1668. X/* increase this for more options */
  1669. X#define MAXOPTS    64
  1670. X
  1671. X#ifndef BITSPERLONG
  1672. X#define BITSPERLONG 32
  1673. X#endif
  1674. X
  1675. Xextern long globalOpts[MAXOPTS/BITSPERLONG];
  1676. X
  1677. X#define options_IsSet(opt) \
  1678. X (globalOpts[(opt)/BITSPERLONG]&(1L<<((opt)%BITSPERLONG)))
  1679. X#define options_Set(opt) \
  1680. X (globalOpts[(opt)/BITSPERLONG]|=(1L<<((opt)%BITSPERLONG)))
  1681. X#define options_Clear(opt) \
  1682. X (globalOpts[(opt)/BITSPERLONG]&=~(1L<<(long)((opt)%BITSPERLONG)))
  1683. X
  1684. Xvoid options_SetByName(char *optname);
  1685. Xvoid options_Init();
  1686. X
  1687. X
  1688. X#define OPT_NONE    0
  1689. X
  1690. X#define OPT_ANSI    1    /* enforce ansi fascism */
  1691. X#define OPT_CPP        2    /* compat with c++ */
  1692. X#define OPT_TRAD    3    /* use traditional style cpp */
  1693. X
  1694. X#define OPT_ABSCODE    4    /* use long (absolute) addressing for function calls */
  1695. X#define OPT_ABSDATA    5    /* use long (absolute) addressing for data */
  1696. X
  1697. X#define OPT_RELOADA4    6    /* reload reg a4 in each function */
  1698. X#define OPT_SHORTINTS    7    /* use short integers */
  1699. X#define OPT_REGARGS    8    /* use register argument passing */
  1700. X#define OPT_LONGALIGN    9    /* align everything to long boundaries */
  1701. X#define OPT_STACKCHECK    10    /* put stack-checking into the func prolog */
  1702. X#define OPT_PURESTRINGS    11    /* put strings in the text segment */
  1703. X
  1704. X#define OPT_FFP        12    /* use mot fast floating point */
  1705. X#define OPT_881        13    /* compile for a 68881 */
  1706. X#define OPT_IEEE    14    /* ieee floating point */
  1707. X
  1708. X#define OPT_68K        15    /* compile for a 68000 and up */
  1709. X#define OPT_020        16    /* compile for a 68020 and up */
  1710. X#define OPT_030        17    /* compile for a 68030 */
  1711. X
  1712. X#define OPT_DETACH    18    /* make a program that runs in the background */
  1713. X#define OPT_TINYMAIN    19    /* use tinymain (this doesn't work) */
  1714. X#define OPT_RESIDENT    20    /* try and make resident-able */
  1715. X#define OPT_CATCH    21    /* compile in code to try and catch exceptions */
  1716. X
  1717. X#define OPT_OPTIMIZE    22    /* optimize the obj module */
  1718. X#define OPT_LINK    23    /* link the object modules */
  1719. X#define OPT_COMPILE    24    /* (otherwise, just pre-process) */
  1720. X#define OPT_ASSEMBLE    25    /* emit object-modules (else assembly) */
  1721. X#define OPT_DEBUG    26    /* produce debugging info */
  1722. X
  1723. X#define OPT_ECHO    27    /* echo what we execute */
  1724. X#define OPT_FILTER    28    /* filter out yucky message from passes */
  1725. X#define OPT_EXEC    29    /* actually run each pass */
  1726. X
  1727. X#define OPT_BIGLC1    30    /* run lc1b instead of lc1 */
  1728. SHAR_EOF
  1729. echo "End of archive 1 (of 1)"
  1730. # if you want to concatenate archives, remove anything after this line
  1731. exit
  1732.